package com.zzyl.nursing.service.impl;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zzyl.nursing.domain.Contract;
import com.zzyl.nursing.mapper.ContractMapper;
import com.zzyl.nursing.service.IContractService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;

/**
 * 合同Service业务层处理
 *
 * @author Liuli
 * @date 2025-08-11
 */
@Service
public class ContractServiceImpl extends ServiceImpl<ContractMapper, Contract> implements IContractService {
    @Autowired
    private ContractMapper contractMapper;

    /**
     * 查询合同
     *
     * @param id 合同主键
     * @return 合同
     */
    @Override
    public Contract selectContractById(Long id) {
        // 根据主键ID查询合同信息
        return contractMapper.selectById(id);
    }

    /**
     * 查询合同列表
     *
     * @param contract 合同查询条件
     * @return 合同列表
     */
    @Override
    public List<Contract> selectContractList(Contract contract) {
        // 根据条件查询合同列表
        return contractMapper.selectContractList(contract);
    }

    /**
     * 新增合同
     *
     * @param contract 合同对象
     * @return 影响行数
     */
    @Override
    public int insertContract(Contract contract) {
        // 插入新的合同记录
        return contractMapper.insert(contract);
    }

    /**
     * 修改合同
     *
     * @param contract 合同对象
     * @return 影响行数
     */
    @Override
    public int updateContract(Contract contract) {
        // 根据主键更新合同信息
        return contractMapper.updateById(contract);
    }

    /**
     * 批量删除合同
     *
     * @param ids 需要删除的合同主键数组
     * @return 影响行数
     */
    @Override
    public int deleteContractByIds(Long[] ids) {
        // 批量删除指定ID的合同记录
        return contractMapper.deleteBatchIds(Arrays.asList(ids));
    }

    /**
     * 删除合同信息
     *
     * @param id 合同主键
     * @return 影响行数
     */
    @Override
    public int deleteContractById(Long id) {
        // 删除指定ID的合同记录
        return contractMapper.deleteById(id);
    }

    /**
     * 更新合同状态
     * 根据当前时间自动更新合同状态(未生效->已生效, 已生效->已过期, 未生效->已失效)
     *
     * @return 默认返回1
     */
    @Override
    @Transactional
    public int updateContractStatus() {
        // 获取当前时间用于状态判断
        LocalDateTime now = LocalDateTime.now();

        //0->1 未生效->已生效
        //查询所有未生效且当前时间在合同有效期内的合同
        List<Contract> contracts = this.list(new LambdaQueryWrapper<Contract>()
                .eq(Contract::getStatus, 0)  // 状态为未生效(0)
                .le(Contract::getStartDate, now)  // 开始时间小于等于当前时间
                .ge(Contract::getEndDate, now));  // 结束时间大于等于当前时间
        // 如果查询到符合条件的合同记录
        if (contracts != null && !contracts.isEmpty()) {
            // 遍历所有合同，将状态更新为已生效(1)
            for (Contract contract : contracts) {
                contract.setStatus(1);
            }
            // 批量更新合同状态
            this.updateBatchById(contracts);
        }

        //1->2 已生效->已过期
        //查询所有已生效且结束时间小于当前时间的合同
        contracts = this.list(new LambdaQueryWrapper<Contract>()
                .eq(Contract::getStatus, 1)  // 状态为已生效(1)
                .le(Contract::getEndDate, now));  // 结束时间小于等于当前时间
        // 如果查询到符合条件的合同记录
        if (contracts != null && !contracts.isEmpty()) {
            // 遍历所有合同，将状态更新为已过期(2)
            for (Contract contract : contracts) {
                contract.setStatus(2);
            }
            // 批量更新合同状态
            this.updateBatchById(contracts);
        }

        //0->3 未生效->已失效
        //查询所有未生效且结束时间小于当前时间的合同
        contracts = this.list(new LambdaQueryWrapper<Contract>()
                .eq(Contract::getStatus, 0)  // 状态为未生效(0)
                .lt(Contract::getEndDate, now));  // 结束时间小于当前时间
        // 如果查询到符合条件的合同记录
        if (contracts != null && !contracts.isEmpty()) {
            // 遍历所有合同，将状态更新为已失效(3)
            for (Contract contract : contracts) {
                contract.setStatus(3);
            }
            // 批量更新合同状态
            this.updateBatchById(contracts);
        }

        // 返回默认值1
        return 1;
    }
}
